﻿//using System;
//using System.Collections.Concurrent;
//using System.Collections.Generic;
//using System.Diagnostics;
//using System.Linq;
//using System.Text;
//using System.Threading;
//using System.IO.Ports;
//using TYBases;
//using TYBase;

//namespace TYCDC.Equip
//{
//    public class MidHelper : IDisposable
//    {
//        public ModelReadBase modelRead = new ModelReadBase();
//        private bool isRunning = true;
//        Thread m_thread;

//        private static readonly MidHelper instance = new MidHelper();

//        private MidHelper()
//        {
//        }

//        public static MidHelper GetInstance()
//        {
//            return instance;
//        }

//        public void Init(int _port, int _baudRate, Parity _parity = Parity.None, int _dataBits = 8, StopBits _stopBits = StopBits.One)
//        {
//            rtuManager = new RTUManager(_port, _baudRate, _parity, _dataBits, _stopBits);
//        }

//        private bool _IsConnect;

//        public bool IsConnect
//        {
//            get { return _IsConnect; }
//        }

//        public bool Connect()
//        {
//            _IsConnect = rtuManager != null && rtuManager.Connect();
//            return _IsConnect;
//        }
//        private readonly object lockSeq = new object();
//        private int _SeqNo = 1;
//        private int SeqNo
//        {
//            get
//            {
//                lock (lockSeq)
//                {
//                    if (_SeqNo + 1 > 9999)
//                    {
//                        _SeqNo = 1;
//                    }

//                    return _SeqNo;
//                }
//            }
//        }

//        private readonly object lockRw = new object();
//        public RTUManager rtuManager;
//        public bool SendData(ModelSendBase modelSendBase)
//        {
//            if (isRunning == false)
//                return false; ;
//            ModelReadError modelReadError = new ModelReadError();
//            if (modelSendBase.FrameBody())
//            {
//                if (rtuManager != null && rtuManager.IsConnected)
//                {
//                    lock (lockRw)
//                    {
//                        LogHelper.Info($"send-命令:{modelSendBase.CMD}-屏号:{modelSendBase.CabinetNo} 数据:{modelSendBase.Message.TYToString()}");
//                        rtuManager.Write(modelSendBase.Message.ToArray());

//                        if (modelSendBase.ModelRead == null)
//                        {
//                            modelSendBase.SetError(EnumReadSatus.未定义返回数据);
//                        }
//                        else
//                        {
//                            Stopwatch sw = new Stopwatch();
//                            sw.Start();
//                            byte[] byteRead = null;
//                            while (true)
//                            {
//                                if (isRunning == false)
//                                    return false; ;
//                                if (sw.ElapsedMilliseconds > 2000)
//                                {
//                                    sw.Stop();
//                                    LogHelper.Info($"get-outtime-命令:{modelSendBase.CMD}-屏号:{modelSendBase.CabinetNo} 数据:{byteRead.TYToString()}");
//                                    modelSendBase.SetError(EnumReadSatus.超时无数据);
//                                    break;
//                                }
//                                byte[] data = null;
//                                if (rtuManager?.Read(out data) > 0)
//                                {
//                                    if (data == null)
//                                    {
//                                        continue;
//                                    }
//                                    if (byteRead == null)
//                                    {
//                                        byteRead = data;
//                                    }
//                                    else
//                                    {
//                                        byte[] dataTmp = new byte[byteRead.Length + data.Length];
//                                        Array.Copy(byteRead, dataTmp, byteRead.Length);
//                                        Array.Copy(data, 0, dataTmp, byteRead.Length, data.Length);
//                                        byteRead = dataTmp;
//                                    }

//                                    if (byteRead.Length < modelRead.ByteHeader.Length)
//                                    {
//                                        continue;
//                                    }

//                                    int index = byteRead.LastIndexof(modelRead.ByteHeader);
//                                    if (index == -1)
//                                    {
//                                        LogHelper.Info($"get-error-命令:{modelSendBase.CMD}-屏号:{modelSendBase.CabinetNo} 数据:{byteRead.TYToString()}");
//                                        byteRead = null;
//                                        continue;
//                                    }
//                                    byte[] byteRealData = new byte[byteRead.Length - index];
//                                    Array.Copy(byteRead, index, byteRealData, 0, byteRealData.Length);

//                                    if (modelSendBase.ModelRead.Resolving(byteRealData))
//                                    {
//                                        LogHelper.Info($"get-命令:{modelSendBase.CMD}-屏号:{modelSendBase.CabinetNo} 数据:{byteRealData.TYToString()}");
//                                        return true;
//                                    }
//                                }
//                                Thread.Sleep(10);
//                            }
//                        }
//                    }
//                }
//                else
//                {
//                    modelSendBase.SetError(EnumReadSatus.未连接);
//                }

//            }
//            else
//            {
//                modelSendBase.SetError(EnumReadSatus.发送组帧失败);
//            }

//            return false;
//        }

//        internal bool OpenCOM()
//        {
//            return rtuManager.Connect();
//        }

//        bool isRead = false;

//        //前导码+机屏号+通道号+数据长度+通信命令（仅上位机才有）+ 数据 + 校验码
//        private byte[] SplitStartEnd(byte[] dataTmp, int len = -1, int trueLen = -1)
//        {
//            try
//            {
//                int msgIndex = dataTmp.SearchBytes(modelRead.ByteHeader);
//                if (msgIndex >= 0)
//                {
//                    #region 取出从头开始的所有数据
//                    byte[] leftData = null;
//                    if (msgIndex != 0)
//                    {
//                        leftData = new byte[dataTmp.Length - msgIndex];
//                        Array.Copy(dataTmp, msgIndex, leftData, 0, dataTmp.Length - msgIndex);
//                    }
//                    else
//                    {
//                        leftData = dataTmp;
//                    }
//                    #endregion
//                    int msgHeadLength = modelRead.ByteHeader.Length + 1 + 1;//数据前的长[度
//                    int msgEndLength = 1;
//                    //A5 A5 AC 01 01 01 03
//                    if (leftData.Length >= msgHeadLength + 1)//前导码+机屏号+数据长度+通信命令（仅上位机才有）+ 数据 + 校验码
//                    {
//                        byte length = leftData[modelRead.ByteHeader.Length + 1 + 1];//代表数据长度
//                        //获取了数据长度后就知道总体长度
//                        int msgLength = msgHeadLength + msgEndLength + length;//数据和crc
//                        if (leftData.Length >= msgLength)//去掉数据+数据
//                        {
//                            byte[] bodyData = new byte[length];
//                            Array.Copy(leftData, msgHeadLength, bodyData, 0, length);
//                            byte crc = leftData[msgHeadLength + length];
//                            //取得校验码
//                            //机屏号、数据长度（为了方便检查，以
//                            //通信发送的数值，即未转换的长度来计算，而不是按实际发送的数据的长度来计算)、通信命令、所有数据（以字节相加）的和（取最低字节）。

//                            if (crc == (byte)(leftData[modelRead.ByteHeader.Length]
//                                + length +
//                                (bodyData.Sum(x => x)) & 0xFF))
//                            //机屏号、数据长度（为了方便检查，以通信发送的数值，即未转换的长度来计算
//                            //，而不是按实际发送的数据的长度来计算)、通信命令、所有数据（以字节相加）的和（取最低字节）。
//                            {
//                                //说明数据是ok 的
//                                byte[] byteQueue = new byte[msgLength];
//                                Array.Copy(leftData, byteQueue, msgLength);//这个要复制完整的数据了
//                                //QueueRead.Enqueue(byteQueue);//获得完整的数据
//                                if (leftData.Length > msgLength)
//                                {
//                                    byte[] data2 = new byte[leftData.Length - msgLength];
//                                    Array.Copy(leftData, msgLength, data2, 0, leftData.Length - msgLength);
//                                    return SplitStartEnd(data2);
//                                }
//                                else
//                                {
//                                    return null;//数据刚刚好
//                                }
//                            }
//                            else
//                            {
//                                byte[] ret = RemoveFirst(leftData);
//                                return SplitStartEnd(ret);
//                            }
//                        }
//                        else
//                        {
//                            return leftData;//数据不够,等下一波
//                        }
//                    }
//                    else
//                    {
//                        return leftData;//数据不够,等下一波
//                    }
//                }
//                else
//                {
//                    return null;
//                }
//            }
//            catch (Exception)
//            {
//                return null;
//            }

//        }

//        public byte[] RemoveFirst(byte[] byteIn)
//        {
//            if (byteIn.Length > 1)
//            {
//                byte[] byteRet = new byte[byteIn.Length - 1];
//                Array.Copy(byteIn, 1, byteRet, 0, byteIn.Length - 1);
//                return byteRet;
//            }
//            return null;
//        }

//        public void Dispose()
//        {
//            isRunning = false;
//        }

//        //internal static EnumReadSatus Stop(byte item)
//        //{
//        //    ModelSendBase modelSendBase = new ModelSendBase()
//        //    {
//        //        CMD = (int)EnumCmds.StopWork,
//        //        CabinetNo = item,
//        //        ModelRead = new Model_Read_NoData()
//        //    };
//        //    ModelReadBase data = SendData(modelSendBase);
//        //    if (data is ModelReadError modelReadError)
//        //    {
//        //        return modelReadError.enumReadErrors;
//        //    }
//        //    else
//        //    {
//        //        return EnumReadSatus.OK;
//        //    }
//        //}

//        //internal static ModelReadBase ReadRTData(byte cabintNo)
//        //{
//        //    ModelSendBase modelSendBase = new ModelSendBase()
//        //    {
//        //        CabinetNo = cabintNo,
//        //        CMD = (int)EnumCmds.GetRT,
//        //        ModelRead = new Model_Read_ReadRT()
//        //    };
//        //    return SendData(modelSendBase);
//        //}

//        //internal static ModelReadBase GetSendStep(byte cabintNo, byte stepNo)
//        //{
//        //    Model_Send_ReadStep modelSendBase = new Model_Send_ReadStep()
//        //    {
//        //        CabinetNo = cabintNo,
//        //        CMD = (int)EnumCmds.ReadStep,
//        //        StepNo = stepNo,
//        //        ModelRead = new Model_Read_GetStep()
//        //    };
//        //    return SendData(modelSendBase);
//        //}

//        //internal static EnumReadSatus SendStep(byte cabinetNo, List<Model_Send_SendStep> listSendStep)
//        //{
//        //    foreach (Model_Send_SendStep item in listSendStep)
//        //    {
//        //        item.CabinetNo = cabinetNo;
//        //        ModelReadBase ret = SendData(item);
//        //        if (ret is ModelReadError modelRead)
//        //        {
//        //            return modelRead.enumReadErrors;
//        //        }
//        //    }
//        //    return EnumReadSatus.OK;
//        //}

//    }
//}